/**
 * 基础API地址
 * @type {string}
 */
const BASE_URL = 'https://gxq.jifgou.com/api'
/**
 * 默认请求超时时间（毫秒）
 * @type {number}
 */
const DEFAULT_TIMEOUT = 10000
/**
 * 最大重试次数
 * @type {number}
 */
const MAX_RETRY_COUNT = 2

/**
 * 构建完整的请求URL
 * @param {string} url - 请求路径
 * @param {Object} [params] - 查询参数
 * @returns {string} 完整的URL
 */
const buildFullUrl = (url, params) => {
	if (!params) return url

	const queryString = Object.entries(params)
		.filter(([_, value]) => value !== undefined && value !== null && value !== '')
		.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
		.join('&')

	return queryString ? `${url}?${queryString}` : url
}

/**
 * 获取请求头
 * @param {Object} [customHeader] - 自定义请求头
 * @returns {Object} 合并后的请求头
 */
const getHeaders = (customHeader = {}) => {
	// 从storage获取完整token对象（而不仅仅是token字符串）
	const tokenData = uni.getStorageSync('token')
	const defaultHeader = {
		'Content-Type': 'application/json',
		...(tokenData?.access_token && {
			'Authorization': `${tokenData.token_type || 'Bearer'} ${tokenData.access_token}`
		})
	}

	return {
		...defaultHeader,
		...customHeader
	}
}

// utils/request.js

/**
 * 处理响应
 * @param {Object} response - 响应对象
 * @returns {Promise} 处理后的响应数据或错误
 */
const handleResponse = (response) => {
	const {
		statusCode,
		data
	} = response;

	// HTTP层成功（200-299）
	if (statusCode >= 200 && statusCode < 300) {
		// 业务层自定义状态码处理
		if (data?.code !== undefined) {
			// 特殊处理402状态（需注册）
			if (data.code === 402) {
				return Promise.resolve(data); // 改为resolve，传递完整数据
			}
			// 其他非200状态码
			if (data.code !== 200) {
				return Promise.reject(new Error(data.message || '请求失败'));
			}
		}
		return Promise.resolve(data);
	}

	// HTTP层异常
	if (statusCode === 401) {
		return handleUnauthorized('登录已过期，请重新登录');
	}
	return Promise.reject(new Error(data?.message || `请求失败，状态码: ${statusCode}`));
};
/**
 * 处理未授权情况
 * @param {string} message - 错误消息
 */
const handleUnauthorized = async (message) => {
	// const userStore = useUserStore()

	// 1. 清除所有认证信息
	// userStore.clearUserInfo()

	// 2. 显示提示
	uni.showToast({
		title: message,
		icon: 'none',
		duration: 2000
	})

	// 3. 跳转到登录页
	setTimeout(() => {
		uni.reLaunch({
			url: '/pages/user/user'
		})
	}, 2000)

	return Promise.reject(new Error(message))
}
/**
 * 请求函数
 * @param {Object} options - 请求选项
 * @param {string} options.url - 请求路径
 * @param {'GET'|'POST'|'PUT'|'DELETE'|'PATCH'} [options.method='GET'] - 请求方法
 * @param {Object} [options.params] - URL查询参数
 * @param {Object} [options.data] - 请求体数据
 * @param {Object} [options.header] - 自定义请求头
 * @param {number} [options.timeout] - 请求超时时间(毫秒)
 * @param {number} [options.retryCount=0] - 当前重试次数(内部使用)
 * @returns {Promise} 请求Promise
 */
export const request = (options) => {
	const {
		url,
		method = 'GET',
		params,
		data = {},
		header,
		timeout = DEFAULT_TIMEOUT,
		retryCount = 0
	} = options

	// 创建请求任务对象以便可以取消请求
	let requestTask = null

	const requestPromise = new Promise((resolve, reject) => {
		const fullUrl = buildFullUrl(url, params)
		const headers = getHeaders(header)

		requestTask = uni.request({
			url: BASE_URL + fullUrl,
			method,
			data,
			header: headers,
			timeout,
			success: (res) => {
				handleResponse(res).then(resolve).catch(reject)
			},
			fail: (err) => {
				// 如果是网络错误且未达到最大重试次数，则自动重试
				if (err.errMsg.includes('network') && retryCount < MAX_RETRY_COUNT) {
					console.warn(`网络错误，第${retryCount + 1}次重试...`)
					request({
						...options,
						retryCount: retryCount + 1
					}).then(resolve).catch(reject)
				} else {
					reject(new Error('网络错误，请稍后重试'))
				}
			}
		})
	})

	// 添加取消方法
	requestPromise.abort = () => {
		if (requestTask) {
			requestTask.abort()
		}
	}

	return requestPromise
}